import Taro from '@tarojs/taro'

// 直接使用HTTP访问地址（通常从云开发控制台获取）
// 注意：这是一个示例URL，你需要在微信云开发控制台中获取你上传文件的实际HTTP访问地址
const RECIPE_HTTP_URL =
  'https://636c-cloud1-1ghcuz1u4c694d57-1304750880.tcb.qcloud.la/json/recipes.json?sign=f1cb237c848557bcf10a9191464bb61b&t=1746603074'

// 本地缓存键前缀
const RECIPE_CACHE_KEY_PREFIX = 'RECIPE_DATA_CHUNK_'
const RECIPE_META_KEY = 'RECIPE_META_INFO'
// 缓存有效期（24小时，单位毫秒）
const CACHE_EXPIRY = 24 * 60 * 60 * 1000

// 缓存版本控制
const CACHE_VERSION = '1.0.1'
const CACHE_VERSION_KEY = 'RECIPES_CACHE_VERSION'

// 分片大小 - 每片最多存储50个菜谱
const CHUNK_SIZE = 50

/**
 * 食谱数据服务
 */
export default {
  /**
   * 获取食谱数据（优先从缓存，缓存不存在或过期则从云端获取）
   * @returns {Promise<Array>} 食谱数据
   */
  async getRecipes() {
    try {
      // 检查缓存版本
      const cachedVersion = Taro.getStorageSync(CACHE_VERSION_KEY)
      if (cachedVersion !== CACHE_VERSION) {
        console.log('缓存版本已更新，清除旧缓存')
        this.clearAllCache()
        Taro.setStorageSync(CACHE_VERSION_KEY, CACHE_VERSION)
      }

      // 尝试从缓存获取元数据
      const metaInfo = Taro.getStorageSync(RECIPE_META_KEY)

      if (metaInfo && metaInfo.timestamp && metaInfo.totalChunks && metaInfo.totalRecipes) {
        const now = new Date().getTime()
        // 检查缓存是否过期
        if (now - metaInfo.timestamp < CACHE_EXPIRY) {
          console.log('从缓存加载食谱数据')
          return this.loadRecipesFromCache(metaInfo.totalChunks, metaInfo.totalRecipes)
        }
        console.log('缓存已过期，重新获取')
      }

      // 从云端获取数据
      console.log('从云端获取食谱数据')
      const result = await this.fetchRecipesFromCloud()
      return result
    } catch (error) {
      console.error('获取食谱数据失败:', error)
      // 尝试从缓存获取元数据，即使已经过期
      const metaInfo = Taro.getStorageSync(RECIPE_META_KEY)

      if (metaInfo && metaInfo.totalChunks && metaInfo.totalRecipes) {
        console.log('获取失败，使用可能过期的缓存')
        try {
          return this.loadRecipesFromCache(metaInfo.totalChunks, metaInfo.totalRecipes)
        } catch (cacheError) {
          console.error('从缓存加载失败:', cacheError)
        }
      }

      // 如果没有缓存数据或加载缓存失败，则抛出错误
      throw new Error('无法获取食谱数据')
    }
  },

  /**
   * 从缓存加载所有菜谱数据
   * @param {number} totalChunks 总分片数
   * @param {number} totalRecipes 总菜谱数量
   * @returns {Array} 合并后的菜谱数据
   */
  loadRecipesFromCache(totalChunks, totalRecipes) {
    let allRecipes = []

    // 从每个分片中读取数据并合并
    for (let i = 0; i < totalChunks; i++) {
      const chunkKey = `${RECIPE_CACHE_KEY_PREFIX}${i}`
      const chunk = Taro.getStorageSync(chunkKey)

      if (!chunk || !chunk.data) {
        throw new Error(`缓存数据不完整，缺少分片 ${i}`)
      }

      allRecipes = allRecipes.concat(chunk.data)
    }

    // 检查是否加载了正确数量的菜谱
    if (allRecipes.length !== totalRecipes) {
      console.warn(`菜谱数量不匹配：预期 ${totalRecipes}，实际 ${allRecipes.length}`)
    }

    return allRecipes
  },

  /**
   * 将菜谱数据分片存储到缓存中
   * @param {Array} recipes 菜谱数据
   */
  saveRecipesToCache(recipes) {
    if (!recipes || !recipes.length) return

    // 计算需要的分片数量
    const totalChunks = Math.ceil(recipes.length / CHUNK_SIZE)

    // 存储元数据
    Taro.setStorageSync(RECIPE_META_KEY, {
      timestamp: new Date().getTime(),
      totalChunks,
      totalRecipes: recipes.length
    })

    // 分片存储
    for (let i = 0; i < totalChunks; i++) {
      const start = i * CHUNK_SIZE
      const end = Math.min(start + CHUNK_SIZE, recipes.length)
      const chunk = recipes.slice(start, end)

      const chunkKey = `${RECIPE_CACHE_KEY_PREFIX}${i}`
      Taro.setStorageSync(chunkKey, {
        data: chunk,
        chunkIndex: i
      })
    }

    console.log(`菜谱数据已分片存储：${totalChunks}个分片，共${recipes.length}条菜谱`)
  },

  /**
   * 从云端获取食谱数据
   * @returns {Promise<Array>} 食谱数据
   */
  async fetchRecipesFromCloud() {
    try {
      Taro.showLoading({ title: '加载中...' })

      // 使用HTTP请求直接获取JSON数据
      const { statusCode, data } = await Taro.request({
        url: RECIPE_HTTP_URL,
        method: 'GET'
      })

      Taro.hideLoading()

      if (statusCode === 200 && data) {
        // 分片存储数据
        this.saveRecipesToCache(data)
        return data
      } else {
        throw new Error('获取数据失败')
      }
    } catch (error) {
      Taro.hideLoading()
      console.error('从云端获取食谱失败:', error)
      throw error
    }
  },

  /**
   * 清除所有缓存
   */
  clearAllCache() {
    try {
      // 获取元数据
      const metaInfo = Taro.getStorageSync(RECIPE_META_KEY)

      // 如果存在元数据，删除所有分片
      if (metaInfo && metaInfo.totalChunks) {
        for (let i = 0; i < metaInfo.totalChunks; i++) {
          const chunkKey = `${RECIPE_CACHE_KEY_PREFIX}${i}`
          Taro.removeStorageSync(chunkKey)
        }
      }

      // 删除元数据
      Taro.removeStorageSync(RECIPE_META_KEY)
      console.log('所有菜谱缓存已清除')
    } catch (error) {
      console.error('清除缓存失败:', error)
    }
  }
}
